package com.chushouya.product.service.admin.impl;

import com.general.framework.core.enums.StatusEnum;
import com.general.framework.core.exception.Ex;
import com.general.framework.core.lang.Lists;
import com.general.framework.core.lang.Numbers;
import com.general.framework.core.lang.Beans;
import com.general.framework.core.lang.Check;
import com.chushouya.product.dao.entity.EvaluateItemEntity;
import com.chushouya.product.dao.entity.SkuEvaluateItemValueEntity;
import com.chushouya.product.dao.repository.EvaluateItemRepository;
import com.chushouya.product.dao.repository.SkuEvaluateItemValueRepository;
import com.chushouya.product.dto.admin.evaluateitem.EvaluateItemQuery;
import com.chushouya.product.dto.admin.evaluateitem.EvaluateItemValueQuery;
import com.chushouya.product.dto.admin.product.evaluate.SkuEvaluateItemValueAddDTO;
import com.chushouya.product.dto.admin.product.evaluate.SkuEvaluateItemValueDTO;
import com.chushouya.product.dto.admin.product.evaluate.SkuEvaluateItemValueEditDTO;
import com.chushouya.product.dto.admin.product.evaluate.SkuItemDTO;
import com.chushouya.product.dto.admin.product.evaluate.SkuItemValueDTO;
import com.chushouya.product.dao.entity.SkuEvaluateItemEntity;
import com.chushouya.product.dao.repository.SkuEvaluateItemRepository;
import com.chushouya.product.dao.entity.EvaluateItemValueEntity;
import com.chushouya.product.dao.repository.EvaluateItemValueRepository;
//=====product.dto.admin.skuevaluate.*;
import com.chushouya.product.dto.admin.skuevaluate.SkuEvaluateItemAddSingleDTO;
import com.chushouya.product.dto.admin.skuevaluate.SkuEvaluateItemQuery;
import com.chushouya.product.dto.admin.skuevaluate.SkuEvaluateItemValueDetailDTO;
import com.chushouya.product.dto.admin.skuevaluate.SkuEvaluateItemValueQuery;
import com.chushouya.product.service.admin.SkuEvaluateItemValueService;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.util.Strings;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * SKU估价项目选项业务实现
 */
@Service
@Slf4j
public class SkuEvaluateItemValueServiceImpl implements SkuEvaluateItemValueService {

    @Resource
    private SkuEvaluateItemValueRepository skuEvaluateItemValueRepository;
    
    @Resource
    private SkuEvaluateItemRepository skuEvaluateItemRepository;
    
    @Resource
    private EvaluateItemValueRepository evaluateItemValueRepository;


    @Resource
    private EvaluateItemRepository evaluateItemRepository;

    @Override
    public Boolean addSkuEvaluateItemValue(SkuEvaluateItemValueAddDTO addDTO) {
        Check.notNull(addDTO, "添加参数不能为空");
        Check.notNull(addDTO.getItemId(), "估价项目ID不能为空");
        final Long productId = addDTO.getProductId();
        final Long itemId = addDTO.getItemId();
        
        // 0. 根据productId批量删除之前的记录
        skuEvaluateItemValueRepository.deleteByProductId(productId,itemId);
        skuEvaluateItemRepository.deleteByProductId(productId,itemId);
        
        // 1. 根据itemId获取对应的evaluate_item_id
        EvaluateItemValueQuery query = new EvaluateItemValueQuery();
        query.setEvaluateItemId(addDTO.getItemId());
        List<EvaluateItemValueEntity> evaluateItemValueList = evaluateItemValueRepository.selectList(query);

        EvaluateItemQuery evaluateItemQuery = new EvaluateItemQuery();
        evaluateItemQuery.setEvaluateItemId(addDTO.getItemId());
        EvaluateItemEntity evaluateItemEntity = evaluateItemRepository.selectOne(evaluateItemQuery);
        if (Lists.isEmpty(evaluateItemValueList)) {
            throw Ex.business("估价项目不存在");
        }

        // 2. 先插入对应的SKU项目到 SkuEvaluateItemEntity
        Date now = new Date();
        
        // 检查SKU项目是否已存在
        SkuEvaluateItemEntity skuEvaluateItem = new SkuEvaluateItemEntity();
        skuEvaluateItem.setProductId(productId);
        skuEvaluateItem.setItemId(evaluateItemEntity.getEvaluateItemId());
        skuEvaluateItem.setItemName(evaluateItemEntity.getItemName());
        skuEvaluateItem.setSelectType(evaluateItemEntity.getSelectType()); // 默认选择类型
        skuEvaluateItem.setSort(evaluateItemEntity.getSort());
        skuEvaluateItem.setStatus(StatusEnum.normal.value());
        skuEvaluateItem.setCreateTime(now);

        skuEvaluateItemRepository.insert(skuEvaluateItem);
        Long skuItemId = skuEvaluateItem.getSkuItemId();
        
        // 3. 为每个选项值创建SKU估价项目选项记录
        List<SkuEvaluateItemValueEntity> entityList = new ArrayList<>();
        
        for (EvaluateItemValueEntity evaluateValue : evaluateItemValueList) {
            SkuEvaluateItemValueEntity entity = new SkuEvaluateItemValueEntity();
            entity.setProductId(productId);
            entity.setSkuItemId(skuItemId);
            entity.setItemName(evaluateValue.getEvaluateItemName());
            entity.setItemId(evaluateValue.getEvaluateItemId());
            entity.setValueId(evaluateValue.getEvaluateValueId());
            entity.setValueName(evaluateValue.getValueContent());
            entity.setValue(BigDecimal.ZERO); // 默认价格为0
            entity.setCalcType(Numbers.INTEGER_ONE);
            entity.setSort(evaluateValue.getSort());
            entity.setStatus(StatusEnum.normal.value());
            entity.setCreateTime(now);
            
            entityList.add(entity);
        }
        
        // 批量插入
        return skuEvaluateItemValueRepository.insertList(entityList) > 0;
    }

    @Override
    public List<SkuEvaluateItemValueDTO> getSkuEvaluateItemValuesByProductId(Long productId) {
        Check.notNull(productId, "商品ID不能为空");
        
        List<SkuEvaluateItemValueEntity> entities = skuEvaluateItemValueRepository.selectByProductId(productId);
        return Beans.copyList(entities, SkuEvaluateItemValueDTO.class);
    }

    @Override
    public Boolean updateSkuEvaluateItemValuePrice(SkuEvaluateItemValueEditDTO editDTO) {
        Check.notNull(editDTO, "修改参数不能为空");
        Check.notNull(editDTO.getSkuItemValueId(), "估价项目选项ID不能为空");
        
        SkuEvaluateItemValueEntity entity = skuEvaluateItemValueRepository.selectByPrimaryKey(editDTO.getSkuItemValueId());
        if (entity == null) {
            throw new RuntimeException("估价项目选项不存在");
        }
        
        if (editDTO.getValue() != null) {
            entity.setValue(editDTO.getValue());
        }
        if (Strings.isNotEmpty(editDTO.getValueName())) {
            entity.setValueName(editDTO.getValueName());
        }

        return skuEvaluateItemValueRepository.updateByPrimaryKey(entity) > 0;
    }

    @Override
    public List<SkuItemDTO> getSkuItemsByProductId(Long productId) {
        Check.notNull(productId, "商品ID不能为空");

        SkuEvaluateItemQuery itemQuery = new SkuEvaluateItemQuery();
        itemQuery.setProductId(productId);

        List<SkuEvaluateItemEntity> skuEvaluateItemList = skuEvaluateItemRepository.selectList(itemQuery);
        if (skuEvaluateItemList.isEmpty()) {
            return new ArrayList<>();
        }
        SkuEvaluateItemValueQuery valueQuery = new SkuEvaluateItemValueQuery();
        valueQuery.setProductId(productId);
        
        // 获取所有SKU估价项目选项值
        List<SkuEvaluateItemValueEntity> allValues = skuEvaluateItemValueRepository.selectList(valueQuery);
        if (allValues.isEmpty()) {
            return new ArrayList<>();
        }

        log.info("SKU估价项目选项值: {}", allValues);
        
        // 按ItemId分组
        Map<Long, List<SkuEvaluateItemValueEntity>> valueMap = allValues.stream()
                .collect(Collectors.groupingBy(SkuEvaluateItemValueEntity::getSkuItemId));
        
        // 按照skuEvaluateItemList的sort顺序构建层次化结构
        List<SkuItemDTO> result = new ArrayList<>();
        for (SkuEvaluateItemEntity skuEvaluateItem : skuEvaluateItemList) {
            Long skuItemId = skuEvaluateItem.getSkuItemId();
            List<SkuEvaluateItemValueEntity> values = valueMap.get(skuItemId);
            
            if (values != null && !values.isEmpty()) {
                SkuItemDTO skuItemDTO = new SkuItemDTO();
                skuItemDTO.setSkuItemId(skuItemId);
                skuItemDTO.setItemId(skuEvaluateItem.getItemId());
                skuItemDTO.setItemName(skuEvaluateItem.getItemName()); // 使用skuEvaluateItem的项目名称
                skuItemDTO.setSelectType(skuEvaluateItem.getSelectType());
                // 构建选项值列表
                List<SkuItemValueDTO> valueList = values.stream()
                        .map(value -> new SkuItemValueDTO(
                                value.getSkuItemValueId(),
                                value.getValueId(),
                                value.getValueName(),
                                value.getValue(),
                                value.getSort()
                        ))
                        .sorted(Comparator.comparing(SkuItemValueDTO::getSort, Comparator.nullsLast(Comparator.naturalOrder())))
                        .collect(Collectors.toList());
                
                skuItemDTO.setSkuItemValueList(valueList);
                result.add(skuItemDTO);
            }
        }
        
        return result;
    }

    @Override
    public Boolean deleteSkuEvaluateItemBySkuItemId(Long skuItemId, Long productId) {
        Check.notNull(skuItemId, "SKU估价项目ID不能为空");
        Check.notNull(productId, "商品ID不能为空");
        
        // 删除该SKU项目下的所有选项值
        return skuEvaluateItemValueRepository.deleteBySkuItemIdAndProductId(skuItemId, productId) >= 0;
    }

    @Override
    public Boolean deleteSkuEvaluateItemValueById(Long skuItemValueId) {
        Check.notNull(skuItemValueId, "SKU估价项目选项ID不能为空");
        
        // 检查记录是否存在
        SkuEvaluateItemValueEntity entity = skuEvaluateItemValueRepository.selectByPrimaryKey(skuItemValueId);
        if (entity == null) {
            throw Ex.business("SKU估价项目选项不存在");
        }
        
        return skuEvaluateItemValueRepository.deleteByPrimaryKey(skuItemValueId) > 0;
    }

    @Override
    public Boolean editSkuEvaluateItemValue(SkuEvaluateItemValueEditDTO editDTO) {
        Check.notNull(editDTO, "编辑参数不能为空");
        Check.notNull(editDTO.getSkuItemValueId(), "SKU估价项目选项ID不能为空");
        
        // 检查记录是否存在
        SkuEvaluateItemValueEntity entity = skuEvaluateItemValueRepository.selectByPrimaryKey(editDTO.getSkuItemValueId());
        if (entity == null) {
            throw Ex.business("SKU估价项目选项不存在");
        }
        
        // 更新字段
        boolean hasUpdate = false;
        if (Strings.isNotEmpty(editDTO.getValueName())) {
            entity.setValueName(editDTO.getValueName());
            hasUpdate = true;
        }
        if (editDTO.getValue() != null) {
            entity.setValue(editDTO.getValue());
            hasUpdate = true;
        }
        if (editDTO.getSort() != null) {
            entity.setSort(editDTO.getSort());
            hasUpdate = true;
        }
        
        if (!hasUpdate) {
            log.warn("没有需要更新的字段，skuItemValueId: {}", editDTO.getSkuItemValueId());
            return true;
        }
        
//        entity.setUpdateTime(new Date());
        int result = skuEvaluateItemValueRepository.updateByPrimaryKeySelective(entity);
        
        log.info("编辑SKU估价项目选项成功，skuItemValueId: {}, valueName: {}, value: {}, sort: {}", 
                editDTO.getSkuItemValueId(), editDTO.getValueName(), editDTO.getValue(), editDTO.getSort());
        
        return result > 0;
    }

    @Override
    public SkuEvaluateItemValueDetailDTO getSkuEvaluateItemValueDetail(Long skuItemValueId) {
        Check.notNull(skuItemValueId, "SKU估价项目选项ID不能为空");
        
        // 检查记录是否存在
        SkuEvaluateItemValueEntity entity = skuEvaluateItemValueRepository.selectByPrimaryKey(skuItemValueId);
        if (entity == null) {
            throw Ex.business("SKU估价项目选项不存在");
        }
        
        return Beans.copy(entity, SkuEvaluateItemValueDetailDTO.class);
    }

    @Override
    public Boolean addSkuEvaluateItemSingle(SkuEvaluateItemAddSingleDTO addSingleDTO) {
        Check.notNull(addSingleDTO, "添加参数不能为空");
        Check.notNull(addSingleDTO.getProductId(), "商品ID不能为空");
        Check.notNull(addSingleDTO.getEvaluateValueId(), "估价项目ID不能为空");
        
        final Long productId = addSingleDTO.getProductId();
        final Long evaluateValueId = addSingleDTO.getEvaluateValueId();


        
        // 2. 根据evaluateItemId获取对应的evaluate_item_value列表
        EvaluateItemValueQuery valueQuery = new EvaluateItemValueQuery();
        valueQuery.setEvaluateValueId(evaluateValueId);
        EvaluateItemValueEntity evaluateItemValue = evaluateItemValueRepository.selectOne(valueQuery);
        
        if (Objects.isNull(evaluateItemValue)) {
            throw Ex.business("估价项目选项不存在");
        }
        final Long evaluateItemId = evaluateItemValue.getEvaluateItemId();
        SkuEvaluateItemQuery itemQuery = new SkuEvaluateItemQuery();
        itemQuery.setItemId(evaluateItemId);
        itemQuery.setProductId(productId);
        SkuEvaluateItemEntity evaluateItem = skuEvaluateItemRepository.selectOne(itemQuery);
        if (Objects.isNull(evaluateItem)) {
            throw Ex.business("估价项目不存在");
        }
        Long skuItemId = evaluateItem.getSkuItemId();

        SkuEvaluateItemValueQuery itemValueQuery = new SkuEvaluateItemValueQuery();
        itemValueQuery.setValueId(evaluateValueId);
        itemValueQuery.setSkuItemId(skuItemId);
        SkuEvaluateItemValueEntity skuEvaluateItemValue = skuEvaluateItemValueRepository.selectOne(itemValueQuery);
        if (Objects.nonNull(skuEvaluateItemValue)) {
            throw Ex.business("该估价项目选项已存在");
        }

        Date now = new Date();

        // 5. 为每个选项值创建SKU估价项目选项记录到 p_sku_evaluate_item_value
        SkuEvaluateItemValueEntity entity = new SkuEvaluateItemValueEntity();
        entity.setProductId(productId);
        entity.setSkuItemId(skuItemId);
        entity.setItemName(evaluateItemValue.getEvaluateItemName());
        entity.setItemId(evaluateItemValue.getEvaluateItemId());
        entity.setValueId(evaluateItemValue.getEvaluateValueId());
        entity.setValueName(evaluateItemValue.getValueContent());
        entity.setValue(BigDecimal.ZERO); // 默认价格为0
        entity.setCalcType(Numbers.INTEGER_ONE);
        entity.setSort(evaluateItemValue.getSort());
        entity.setStatus(StatusEnum.normal.value());
        entity.setCreateTime(now);
        
        // 插入
        return skuEvaluateItemValueRepository.insert(entity) > 0;
    }

}
